/*
 * Copyright (C) 2009 ZXing authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package cn.ekuma.android.ui.scan.history;

import com.google.zxing.BarcodeFormat;
import com.google.zxing.Result;
import com.openbravo.bean.pda.LocalHistory;

import android.app.Activity;
import android.content.ContentValues;
import android.content.SharedPreferences;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.net.Uri;
import android.os.Environment;
import android.preference.PreferenceManager;
import android.util.Log;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.Charset;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import cn.ekuma.android.ui.scan.Intents;
import cn.ekuma.android.ui.scan.history.upload.LocalHistoryAdapter;
import cn.ekuma.android.ui.scan.result.ResultHandler;
import cn.ekuma.epos.android.Config;
import cn.ekuma.epos.datalogic.local.dao.LocalHistoryDAO;

/**
 * <p>Manages functionality related to scan history.</p>
 *
 * @author Sean Owen
 */
public final class HistoryManager {

  private static final String TAG = HistoryManager.class.getSimpleName();

  private static final int MAX_ITEMS = 500;

  private static final String[] COLUMNS = {
      DBHelper.TEXT_COL,
      DBHelper.DISPLAY_COL,
      DBHelper.FORMAT_COL,
      DBHelper.TIMESTAMP_COL,
      DBHelper.DETAILS_COL,
      DBHelper.UNITS_COL
  };

    public static final int EXPORT_STYLE_CODE=0;
    public static final int EXPORT_STYLE_CODE_UNIT=1;
    public static final int EXPORT_STYLE_CODE_UNIT_NAME=2;


  private static final String[] COUNT_COLUMN = { "COUNT(1)" };

  private static final String[] ID_COL_PROJECTION = { DBHelper.ID_COL };
  private static final String[] ID_DETAIL_COL_PROJECTION = { DBHelper.ID_COL, DBHelper.DETAILS_COL };
  private static final String[] ID_UNITS_COL_PROJECTION = { DBHelper.ID_COL, DBHelper.UNITS_COL };
  private static final DateFormat EXPORT_DATE_TIME_FORMAT = DateFormat.getDateTimeInstance();

  private final Activity activity;

  public HistoryManager(Activity activity) {
    this.activity = activity;
  }

  public boolean hasHistoryItems() {
    SQLiteOpenHelper helper = new DBHelper(activity);
    SQLiteDatabase db = null;
    Cursor cursor = null;
    try {
      db = helper.getReadableDatabase();
      cursor = db.query(DBHelper.TABLE_NAME, COUNT_COLUMN, null, null, null, null, null);
      cursor.moveToFirst();
      return cursor.getInt(0) > 0;
    } finally {
      close(cursor, db);
    }
  }

  public List<HistoryItem> buildHistoryItems() {
    SQLiteOpenHelper helper = new DBHelper(activity);
    List<HistoryItem> items = new ArrayList<HistoryItem>();
    SQLiteDatabase db = null;
    Cursor cursor = null;
    try {
      db = helper.getReadableDatabase();
      cursor = db.query(DBHelper.TABLE_NAME, COLUMNS, null, null, null, null, DBHelper.TIMESTAMP_COL + " DESC");
      while (cursor.moveToNext()) {
        String text = cursor.getString(0);
        String display = cursor.getString(1);
        String format = cursor.getString(2);
        long timestamp = cursor.getLong(3);
        String details = cursor.getString(4);
        double units=cursor.getDouble(5);
        Result result = new Result(text, null, null, BarcodeFormat.valueOf(format), timestamp);
        items.add(new HistoryItem(result, display, details,units));
      }
    } finally {
      close(cursor, db);
    }
    return items;
  }

  public HistoryItem buildHistoryItem(int number) {
    SQLiteOpenHelper helper = new DBHelper(activity);
    SQLiteDatabase db = null;
    Cursor cursor = null;
    try {
      db = helper.getReadableDatabase();
      cursor = db.query(DBHelper.TABLE_NAME, COLUMNS, null, null, null, null, DBHelper.TIMESTAMP_COL + " DESC");
      cursor.move(number + 1);
      String text = cursor.getString(0);
      String display = cursor.getString(1);
      String format = cursor.getString(2);
      long timestamp = cursor.getLong(3);
      String details = cursor.getString(4);
      double units=cursor.getDouble(5);
      Result result = new Result(text, null, null, BarcodeFormat.valueOf(format), timestamp);
      return new HistoryItem(result, display, details,units);
    } finally {
      close(cursor, db);
    }
  }
  
  public void deleteHistoryItem(int number) {
    SQLiteOpenHelper helper = new DBHelper(activity);
    SQLiteDatabase db = null;
    Cursor cursor = null;
    try {
      db = helper.getWritableDatabase();      
      cursor = db.query(DBHelper.TABLE_NAME,
                        ID_COL_PROJECTION,
                        null, null, null, null,
                        DBHelper.TIMESTAMP_COL + " DESC");
      cursor.move(number + 1);
      db.delete(DBHelper.TABLE_NAME, DBHelper.ID_COL + '=' + cursor.getString(0), null);
    } finally {
      close(cursor, db);
    }
  }

  public void addHistoryItem(Result result, ResultHandler handler,String display) {
    // Do not save this item to the history if the preference is turned off, or the contents are
    // considered secure.
    if (!activity.getIntent().getBooleanExtra(Intents.Scan.SAVE_HISTORY, true) ||
        handler.areContentsSecure()) {
      return;
    }

    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(activity);
    if (!prefs.getBoolean(Config.KEY_REMEMBER_DUPLICATES, false)) {
      deletePrevious(result.getText());
    }

    ContentValues values = new ContentValues();
    values.put(DBHelper.TEXT_COL,result.getText());
    values.put(DBHelper.FORMAT_COL, result.getBarcodeFormat().toString());
    values.put(DBHelper.DISPLAY_COL, display);
    values.put(DBHelper.TIMESTAMP_COL, System.currentTimeMillis());
    values.put(DBHelper.UNITS_COL, 1);

    SQLiteOpenHelper helper = new DBHelper(activity);
    SQLiteDatabase db = null;
    try {
      db = helper.getWritableDatabase();      
      // Insert the new entry into the DB.
      db.insert(DBHelper.TABLE_NAME, DBHelper.TIMESTAMP_COL, values);
    } finally {
      close(null, db);
    }
  }

  public void addHistoryItem(HistoryItem item) {
	    ContentValues values = new ContentValues();
	    values.put(DBHelper.TEXT_COL,item.getDisplay());
	    values.put(DBHelper.FORMAT_COL, BarcodeFormat.EAN_13.toString());
	    values.put(DBHelper.DISPLAY_COL, item.getDetails());
	    values.put(DBHelper.TIMESTAMP_COL, System.currentTimeMillis());
	    values.put(DBHelper.UNITS_COL, item.getUnits());

	    SQLiteOpenHelper helper = new DBHelper(activity);
	    SQLiteDatabase db = null;
	    try {
	      db = helper.getWritableDatabase();      
	      // Insert the new entry into the DB.
	      db.insert(DBHelper.TABLE_NAME, DBHelper.TIMESTAMP_COL, values);
	    } finally {
	      close(null, db);
	    }
	  }
  
  public void addHistoryItemDetails(String itemID, String itemDetails) {
    // As we're going to do an update only we don't need need to worry
    // about the preferences; if the item wasn't saved it won't be udpated
    SQLiteOpenHelper helper = new DBHelper(activity);
    SQLiteDatabase db = null;    
    Cursor cursor = null;
    try {
      db = helper.getWritableDatabase();
      cursor = db.query(DBHelper.TABLE_NAME,
                        ID_DETAIL_COL_PROJECTION,
                        DBHelper.TEXT_COL + "=?",
                        new String[] { itemID },
                        null,
                        null,
                        DBHelper.TIMESTAMP_COL + " DESC",
                        "1");
      String oldID = null;
      String oldDetails = null;
      if (cursor.moveToNext()) {
        oldID = cursor.getString(0);
        oldDetails = cursor.getString(1);
      }

      String newDetails = oldDetails == null ? itemDetails : oldDetails + " : " + itemDetails;
      ContentValues values = new ContentValues();
      values.put(DBHelper.DETAILS_COL, newDetails);

      db.update(DBHelper.TABLE_NAME, values, DBHelper.ID_COL + "=?", new String[] { oldID });

    } finally {
      close(cursor, db);
    }
  }
  
  public void updateHistoryItemUnits(String itemID, double units) {
	  SQLiteOpenHelper helper = new DBHelper(activity);
	    SQLiteDatabase db = null;    
	    Cursor cursor = null;
	    try {
	      db = helper.getWritableDatabase();
	      cursor = db.query(DBHelper.TABLE_NAME,
	    		            ID_UNITS_COL_PROJECTION,
	                        DBHelper.TEXT_COL + "=?",
	                        new String[] { itemID },
	                        null,
	                        null,
	                        DBHelper.TIMESTAMP_COL + " DESC",
	                        "1");
	      String oldID = null;
	      if (cursor.moveToNext()) {
	        oldID = cursor.getString(0);
	      }

	      if(oldID==null)
	    	  return;
	      
	      ContentValues values = new ContentValues();
	      values.put(DBHelper.UNITS_COL, units);

	      db.update(DBHelper.TABLE_NAME, values, DBHelper.ID_COL + "=?", new String[] { oldID });

	    } finally {
	      close(cursor, db);
	    }
  }
  

  private void deletePrevious(String text) {
    SQLiteOpenHelper helper = new DBHelper(activity);
    SQLiteDatabase db = null;
    try {
      db = helper.getWritableDatabase();      
      db.delete(DBHelper.TABLE_NAME, DBHelper.TEXT_COL + "=?", new String[] { text });
    } finally {
      close(null, db);
    }
  }

  public void trimHistory() {
    SQLiteOpenHelper helper = new DBHelper(activity);
    SQLiteDatabase db = null;
    Cursor cursor = null;
    try {
      db = helper.getWritableDatabase();      
      cursor = db.query(DBHelper.TABLE_NAME,
                        ID_COL_PROJECTION,
                        null, null, null, null,
                        DBHelper.TIMESTAMP_COL + " DESC");
      cursor.move(MAX_ITEMS);
      while (cursor.moveToNext()) {
        db.delete(DBHelper.TABLE_NAME, DBHelper.ID_COL + '=' + cursor.getString(0), null);
      }
    } finally {
      close(cursor, db);
    }
  }

  /**
   * <p>Builds a text representation of the scanning history. Each scan is encoded on one
   * line, terminated by a line break (\r\n). The values in each line are comma-separated,
   * and double-quoted. Double-quotes within values are escaped with a sequence of two
   * double-quotes. The fields output are:</p>
   *
   * <ul>
   *  <li>Raw text</li>
   *  <li>Display text</li>
   *  <li>Format (e.g. QR_CODE)</li>
   *  <li>Timestamp</li>
   *  <li>Formatted version of timestamp</li>
   * </ul>
   */
 public CharSequence buildHistory(int type) {
    StringBuilder historyText = new StringBuilder(1000);
    SQLiteOpenHelper helper = new DBHelper(activity);
    SQLiteDatabase db = null;
    Cursor cursor = null;
    try {
      db = helper.getWritableDatabase();
      cursor = db.query(DBHelper.TABLE_NAME,
                        COLUMNS,
                        null, null, null, null,
                        DBHelper.TIMESTAMP_COL + " DESC");

      while (cursor.moveToNext()) {
        historyText.append(massageHistoryField(cursor.getString(0)));
          if(type==EXPORT_STYLE_CODE_UNIT)
             historyText.append(",").append(cursor.getDouble(5));
          if(type==EXPORT_STYLE_CODE_UNIT_NAME)
              historyText.append(",").append(massageHistoryField(cursor.getString(1)));
          historyText .append("\r\n");
      }
      return historyText;
    } finally {
      close(cursor, db);
    }
  }

  
 public void clearHistory() {
    SQLiteOpenHelper helper = new DBHelper(activity);
    SQLiteDatabase db = null;
    try {
      db = helper.getWritableDatabase();      
      db.delete(DBHelper.TABLE_NAME, null, null);
    } finally {
      close(null, db);
    }
  }

  public static Uri saveHistory(String history) {
    File bsRoot = new File(Environment.getExternalStorageDirectory(), "BarcodeScanner");
    File historyRoot = new File(bsRoot, "History");
    if (!historyRoot.exists() && !historyRoot.mkdirs()) {
      Log.w(TAG, "Couldn't make dir " + historyRoot);
      return null;
    }
    File historyFile = new File(historyRoot, LocalHistoryAdapter.dateFormat.format(System.currentTimeMillis())+".csv");
    OutputStreamWriter out = null;
    try {
      out = new OutputStreamWriter(new FileOutputStream(historyFile), Charset.forName("UTF-8"));
      out.write(history);
      return Uri.parse("file://" + historyFile.getAbsolutePath());
    } catch (IOException ioe) {
      Log.w(TAG, "Couldn't access file " + historyFile + " due to " + ioe);
      return null;
    } finally {
      if (out != null) {
        try {
          out.close();
        } catch (IOException ioe) {
          // do nothing
        }
      }
    }
  }

  private static String massageHistoryField(String value) {
    return value == null ? "" : value.replace("\"","\"\"");
  }
  
  private static void close(Cursor cursor, SQLiteDatabase database) {
    if (cursor != null) {
      cursor.close();
    }
    if (database != null) {
      database.close();
    }
  }
  
  public void saveLocalHistory(LocalHistory entry){
	  LocalHistoryDAO localHistoryDAO=new LocalHistoryDAO(new DBHelper(activity));
	  localHistoryDAO.insert(entry);
  }

public void clearLocalHistory() {
	LocalHistoryDAO localHistoryDAO=new LocalHistoryDAO(new DBHelper(activity));
	localHistoryDAO.clear();
}

public void deleteLocalHistory(LocalHistory item) {
	LocalHistoryDAO localHistoryDAO=new LocalHistoryDAO(new DBHelper(activity));
	localHistoryDAO.delete(item);
}

public List<LocalHistory> buildLocalHistorys() {
	LocalHistoryDAO localHistoryDAO=new LocalHistoryDAO(new DBHelper(activity));
	return localHistoryDAO.list();
}

public HashMap<String,Double> buildLocalHistory() {
	HashMap<String,Double>   map= new HashMap<String,Double>();
    SQLiteOpenHelper helper = new DBHelper(activity);
    SQLiteDatabase db = null;
    Cursor cursor = null;
    try {
      db = helper.getWritableDatabase();
      cursor = db.query(DBHelper.TABLE_NAME,
                        COLUMNS,
                        null, null, null, null,
                        DBHelper.TIMESTAMP_COL + " DESC");

      while (cursor.moveToNext()) {
    	 map.put(cursor.getString(0), cursor.getDouble(5));
      }
      return map;
    } finally {
      close(cursor, db);
    }
}
}
